'use strict';

// 云对象名：notice-service
module.exports = {
  /**
   * 获取通知列表
   * @param {number} page - 页码
   * @param {number} limit - 每页数量
   * @param {string} category - 分类
   * @param {boolean} showInHome - 是否在首页显示
   * @param {string} title - 标题筛选
   * @param {string} status - 状态筛选
   * @param {string} creatorId - 创建者ID
   * @returns {object} 通知列表
   */
  async getNotices(page = 1, limit = 10, category, showInHome, title, status, creatorId) {
    const db = uniCloud.database();
    const noticesCollection = db.collection('notices');
    
    try {
      // 参数类型转换，确保是整数
      const pageNum = parseInt(page) || 1;
      const limitNum = parseInt(limit) || 10;
      
      // 如果指定了创建者ID，执行管理员获取操作
      if (creatorId) {
        const noticesCollection = db.collection('notices');
        
        // 构建查询条件
        const whereConditions = {};
        
        // 始终排除已删除的公告
        whereConditions.status = db.command.neq('deleted');
        
        // 添加创建者ID筛选 - 同时尝试用户ID的多个可能字段
        whereConditions.$or = [
          { userId: creatorId },
          { creator_id: creatorId }
        ];
        
        // 添加标题筛选
        if (title) {
          whereConditions.title = db.command.regExp({
            regexp: `.*${title}.*`,
            options: 'i'
          });
        }
        
        // 添加分类筛选
        if (category && category !== '全部') {
          whereConditions.category = category;
        }
        
        // 添加状态筛选（如果请求中有指定状态，并且不是排除deleted的条件）
        if (status && status !== '全部' && status !== 'deleted') {
          // 覆盖之前设置的status条件
          whereConditions.status = status;
        }
        
        console.log('管理员公告查询条件:', JSON.stringify(whereConditions));
        
        // 查询公告总数
        const countResult = await noticesCollection.where(whereConditions).count();
        const total = countResult.total;
        
        // 查询公告列表
        const noticesResult = await noticesCollection
          .where(whereConditions)
          .orderBy('publishDate', 'desc')
          .skip((pageNum - 1) * limitNum)
          .limit(limitNum)
          .get();
        
        console.log('管理员公告查询结果:', JSON.stringify(noticesResult.data));
        
        return {
          code: 0,
          message: '获取成功',
          data: noticesResult.data,
          total: total,
          page: pageNum,
          limit: limitNum
        };
      }
      
      // 参数处理
      const skip = (pageNum - 1) * limitNum;
      
      // 构建查询条件
      const where = {
        // 只获取活跃状态的公告，排除已删除的
        status: db.command.neq('deleted')
      };
      
      // 如果指定了分类，则添加分类筛选条件
      if (category) {
        where.category = category;
      }
      
      // 修改过滤逻辑
      if (showInHome === true) {
        // 获取不在轮播显示的公告
        where.showInBanner = false;
      } else if (showInHome === false) {
        // 获取在轮播显示的公告
        where.showInBanner = true;
      }
      
      // 添加调试日志
      console.log('查询条件:', JSON.stringify(where));
      
      // 查询公告总数
      const countResult = await noticesCollection.where(where).count();
      const total = countResult.total;
      
      // 查询公告列表
      const noticesRes = await noticesCollection.where(where)
        .orderBy('publishDate', 'desc') // 按发布日期倒序排序
        .skip(skip)
        .limit(limitNum)
        .field({
          title: true,
          content: true,
          category: true,
          type: true,
          importance: true,
          publishDate: true,
          view_count: true,
          _id: true,
          showInBanner: true,
          status: true  // 添加status字段以便调试
        })
        .get();
        
      // 添加调试日志
      console.log('查询结果:', JSON.stringify(noticesRes.data));
      
      // 返回成功结果
      return {
        code: 0,
        message: '获取公告列表成功',
        data: noticesRes.data,
        total,
        page: pageNum,
        limit: limitNum,
        pages: Math.ceil(total / limitNum)
      };
    } catch (e) {
      // 发生错误时返回错误信息
      console.error('获取公告列表失败', e);
      return {
        code: 1,
        message: '获取公告列表失败: ' + e.message
      };
    }
  },

  /**
   * 获取通知详情
   * @param {string} noticeId - 通知ID
   * @returns {object} 通知详情
   */
  async getNoticeDetail(noticeId) {
    if (!noticeId) {
      return {
        code: -1,
        message: '通知ID不能为空'
      };
    }

    try {
      const db = uniCloud.database();
      
      // 查询通知详情
      const noticeResult = await db.collection('notices')
        .doc(noticeId)
        .get();
      
      if (!noticeResult.data || noticeResult.data.length === 0) {
        return {
          code: -1,
          message: '通知不存在'
        };
      }
      
      const noticeData = Array.isArray(noticeResult.data) ? noticeResult.data[0] : noticeResult.data;
      
      return {
        code: 0,
        message: '获取成功',
        data: noticeData
      };
    } catch (error) {
      console.error('获取通知详情失败:', error);
      return {
        code: -1,
        message: '获取通知详情失败: ' + error.message
      };
    }
  },

  /**
   * 更新通知
   * @param {string} noticeId - 通知ID
   * @param {string} title - 标题
   * @param {string} content - 内容
   * @param {string} category - 分类
   * @param {string} type - 类型
   * @param {string} importance - 重要性
   * @param {boolean} showInBanner - 是否在轮播显示
   * @param {string} status - 状态
   * @param {string} userId - 用户ID
   * @param {string} token - 用户token
   * @param {object} bannerImage - 轮播图片信息
   * @param {array} images - 附件图片列表
   * @param {array} documents - 附件文档列表
   * @param {string} summary - 摘要
   * @param {array} tags - 标签
   * @param {string} publishDate - 发布日期
   * @param {string} endDate - 截止日期
   * @param {string} language - 语言
   * @param {string} startTime - 活动开始时间
   * @param {string} endTime - 活动结束时间
   * @param {string} location - 活动地点
   * @returns {object} 更新结果
   */
  async updateNotice(noticeId, title, content, category, type, importance, showInBanner, status, userId, token, bannerImage, images, documents, summary, tags, publishDate, endDate, language, startTime, endTime, location) {
    try {
      const db = uniCloud.database();
      
      if (!noticeId) {
        return {
          code: -1,
          message: '通知ID不能为空'
        };
      }
      
      // 验证用户权限
      let currentUserId;
      if (userId) {
        currentUserId = userId;
      } else if (token) {
        const tokenResult = await db.collection('users').where({
          token: token
        }).get();
        
        if (tokenResult.data && tokenResult.data.length > 0) {
          currentUserId = tokenResult.data[0]._id;
        }
      }
      
      if (!currentUserId) {
        return {
          code: -1,
          message: '用户未认证'
        };
      }
      
      // 查询通知信息
      const noticeResult = await db.collection('notices').doc(noticeId).get();
      if (!noticeResult.data || noticeResult.data.length === 0) {
        return {
          code: -1,
          message: '通知不存在'
        };
      }
      
      const notice = Array.isArray(noticeResult.data) ? noticeResult.data[0] : noticeResult.data;
      
      // 检查权限
      if (notice.userId !== currentUserId && notice.creator_id !== currentUserId) {
        return {
          code: -1,
          message: '无权限修改此通知'
        };
      }
      
      // 准备更新数据
      const updateData = {
        update_date: new Date()
      };
      
      if (title) updateData.title = title;
      if (content) updateData.content = content;
      if (summary) updateData.summary = summary;
      if (category) updateData.category = category;
      if (type) updateData.type = type;
      if (importance) updateData.importance = importance;
      if (showInBanner !== undefined) updateData.showInBanner = showInBanner;
      if (status) updateData.status = status;
      if (publishDate) updateData.publishDate = new Date(publishDate);
      if (endDate) updateData.endDate = new Date(endDate);
      if (language) updateData.language = language;
      
      // 更新轮播图片信息
      if (bannerImage !== undefined) {
        updateData.bannerImage = bannerImage;
      }
      
      // 更新附件图片列表
      if (images !== undefined) {
        updateData.images = images;
      }
      
      // 更新附件文档列表
      if (documents !== undefined) {
        updateData.documents = documents;
      }
      
      // 更新标签
      if (tags !== undefined) {
        updateData.tags = tags;
      }
      
      // 如果是活动类型，更新活动相关信息
      if (type === 'activity') {
        if (startTime) updateData.startTime = new Date(startTime);
        if (endTime) updateData.endTime = new Date(endTime);
        if (location !== undefined) updateData.location = location;
      }
      
      console.log('准备更新的数据:', {
        noticeId,
        title: updateData.title,
        showInBanner: updateData.showInBanner,
        bannerImage: updateData.bannerImage ? 'yes' : 'no',
        imagesCount: updateData.images ? updateData.images.length : 'unchanged',
        documentsCount: updateData.documents ? updateData.documents.length : 'unchanged'
      });
      
      // 更新通知
      await db.collection('notices').doc(noticeId).update(updateData);
      
      return {
        code: 0,
        message: '更新成功'
      };
    } catch (error) {
      console.error('更新通知失败:', error);
      return {
        code: -1,
        message: '更新失败: ' + error.message
      };
    }
  },

  /**
   * 删除通知
   * @param {string} noticeId - 通知ID
   * @param {string} userId - 用户ID
   * @param {string} token - 用户token
   * @returns {object} 删除结果
   */
  async deleteNotice(noticeId, userId, token) {
    try {
      const db = uniCloud.database();
      
      if (!noticeId) {
        return {
          code: -1,
          message: '通知ID不能为空'
        };
      }
      
      // 验证用户权限
      let currentUserId;
      if (userId) {
        currentUserId = userId;
      } else if (token) {
        const tokenResult = await db.collection('users').where({
          token: token
        }).get();
        
        if (tokenResult.data && tokenResult.data.length > 0) {
          currentUserId = tokenResult.data[0]._id;
        }
      }
      
      if (!currentUserId) {
        return {
          code: -1,
          message: '用户未认证'
        };
      }
      
      // 查询通知信息
      const noticeResult = await db.collection('notices').doc(noticeId).get();
      if (!noticeResult.data || noticeResult.data.length === 0) {
        return {
          code: -1,
          message: '通知不存在'
        };
      }
      
      const notice = Array.isArray(noticeResult.data) ? noticeResult.data[0] : noticeResult.data;
      
      // 检查权限
      if (notice.userId !== currentUserId && notice.creator_id !== currentUserId) {
        return {
          code: -1,
          message: '无权限删除此通知'
        };
      }
      
      // 软删除：更新状态为deleted
      await db.collection('notices').doc(noticeId).update({
        status: 'deleted',
        delete_date: new Date()
      });
      
      return {
        code: 0,
        message: '删除成功'
      };
    } catch (error) {
      console.error('删除通知失败:', error);
      return {
        code: -1,
        message: '删除失败: ' + error.message
      };
    }
  },

  /**
   * 上传通知内容
   * @param {string} title - 标题
   * @param {string} content - 内容
   * @param {string} category - 分类
   * @param {string} type - 类型
   * @param {string} importance - 重要性
   * @param {boolean} showInBanner - 是否在轮播显示
   * @param {string} status - 状态
   * @param {string} userId - 用户ID
   * @param {string} token - 用户token
   * @param {object} bannerImage - 轮播图片信息
   * @param {array} images - 附件图片列表
   * @param {array} documents - 附件文档列表
   * @param {string} summary - 摘要
   * @param {array} tags - 标签
   * @param {string} publishDate - 发布日期
   * @param {string} endDate - 截止日期
   * @param {string} language - 语言
   * @param {string} startTime - 活动开始时间
   * @param {string} endTime - 活动结束时间
   * @param {string} location - 活动地点
   * @returns {object} 上传结果
   */
  async uploadNoticeContent(title, content, category, type, importance, showInBanner, status, userId, token, bannerImage, images, documents, summary, tags, publishDate, endDate, language, startTime, endTime, location) {
    try {
      const db = uniCloud.database();
      
      // 获取当前用户信息
      let currentUserId = '';
      
      if (userId) {
        currentUserId = userId;
        console.log('从参数获取用户ID:', currentUserId);
      } else if (token) {
        try {
          // 尝试从uni-id-users表获取用户信息
          const tokenResult = await db.collection('uni-id-users').where({
            token: token
          }).get();
          
          if (tokenResult.data && tokenResult.data.length > 0) {
            currentUserId = tokenResult.data[0]._id;
            console.log('从uni-id-users获取到用户ID:', currentUserId);
          } else {
            // 如果uni-id-users表中找不到，尝试从users表
            const userResult = await db.collection('users').where({
              token: token
            }).get();
            
            if (userResult.data && userResult.data.length > 0) {
              currentUserId = userResult.data[0]._id;
              console.log('从users获取到用户ID:', currentUserId);
            }
          }
        } catch (error) {
          console.error('解析token出错:', error);
        }
      }
      
      // 验证用户ID
      if (!currentUserId) {
        console.error('未能获取有效的用户ID');
        return {
          code: 401,
          message: '未授权，无法获取用户信息'
        };
      }
      
      // 验证必填参数
      if (!title || !content) {
        return {
          code: -1,
          message: '标题和内容为必填项'
        };
      }
      
      // 创建通知记录
      const noticeData = {
        title,
        content,
        summary: summary || '',
        category: category || 'general',
        type: type || 'notice',
        importance: importance || 'normal',
        showInBanner: !!showInBanner,
        status: status || 'published',
        publishDate: publishDate ? new Date(publishDate) : new Date(),
        endDate: endDate ? new Date(endDate) : null,
        language: language || 'zh-CN',
        create_date: new Date(),
        update_date: new Date(),
        userId: currentUserId,
        creator_id: currentUserId,
        view_count: 0,
        // 添加轮播图片信息
        bannerImage: bannerImage || null,
        // 添加附件图片列表
        images: images || [],
        // 添加附件文档列表
        documents: documents || [],
        // 添加标签
        tags: tags || []
      };
      
      // 如果是活动类型，添加活动相关信息
      if (type === 'activity') {
        noticeData.startTime = startTime ? new Date(startTime) : null;
        noticeData.endTime = endTime ? new Date(endTime) : null;
        noticeData.location = location || '';
      }
      
      console.log('准备保存的通知数据:', {
        title: noticeData.title,
        creator_id: noticeData.creator_id,
        status: noticeData.status,
        showInBanner: noticeData.showInBanner,
        bannerImage: noticeData.bannerImage ? 'yes' : 'no',
        imagesCount: noticeData.images.length,
        documentsCount: noticeData.documents.length
      });
      
      const result = await db.collection('notices').add(noticeData);
      
      console.log('通知保存结果:', result);
      
      return {
        code: 0,
        message: '通知发布成功',
        data: {
          id: result.id
        }
      };
    } catch (error) {
      console.error('通知上传错误：', error);
      return {
        code: -1,
        message: '发布失败：' + error.message
      };
    }
  },

  /**
   * 增加通知浏览量
   * @param {string} noticeId - 通知ID
   * @returns {object} 更新结果
   */
  async increaseNoticeViewCount(noticeId) {
    try {
      const db = uniCloud.database();
      
      if (!noticeId) {
        return {
          code: -1,
          message: '通知ID不能为空'
        };
      }
      
      // 增加浏览量
      await db.collection('notices').doc(noticeId).update({
        view_count: db.command.inc(1)
      });
      
      return {
        code: 0,
        message: '浏览量更新成功'
      };
    } catch (error) {
      console.error('更新浏览量失败:', error);
      return {
        code: -1,
        message: '更新浏览量失败: ' + error.message
      };
    }
  },


}; 